/*********************************************************************
 *  Nome : Bruno Ferrero                             N.USP 3690142
 *  Nome : Mariana Pacheco Hatamura                  N.USP 4906967 
 *  Nome : Tiago Nicolosi Bomventi                   N.USP 3690177 
 *  Curso: BCC                                 Disciplina: MAC 211
 *  Data : 5/5/2010                       Exercic. Projeto(parte 1)
 *  Compilador utilizado : gcc versao 4.1.2
 *  ******************************************************************/

/*nesse arquivo se encontram os setters e getters de itens do jogo*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "item.h"

/*vetor que armazena naufragos*/
static naufrago naufragos[MAX_NAUFRAGOS];
static int proximoNaufrago = 0;
static int numeroNaufragosNoVetor = 0;


/*cria um naufrago no vetor de naufragos*/
int criaNaufrago (float posx, float posy, float vx, float vy){
    int i;
    for (i = 0 ; i < MAX_NAUFRAGOS ; i++) {
        if (naufragos[i].livre == 1) {
            naufragos[i].posx = posx;
            naufragos[i].posy = posy;
            naufragos[i].vx = vx;
            naufragos[i].vy = vy;
            naufragos[i].livre = 0;	
            numeroNaufragosNoVetor++;
            return i;
        }
    }
    return -1;
}

/*remove um naufrago do vetor de naufragos*/
void removeNaufrago (naufrago * passageiro) {
    passageiro->livre = 1;
    numeroNaufragosNoVetor--;
}

/*retorna o numero de naufragos colocados no vetor de naufragos*/
int numNaufragosNoVetor (void) {
    return numeroNaufragosNoVetor;
}

/*inicializa o vetor de naufragos, marcando-os como livres para uso*/
void inicializaVetorNaufragos (void) {
    int i;
    for (i = 0 ; i < MAX_NAUFRAGOS ; i++)
        naufragos[i].livre = 1;
}

/*funcao que obtem o naufrago em funcao de seu indice na matriz oceano. devolve NULL se nao encontra-lo*/
naufrago * getNaufrago (int posi, int posj) {
    int i;
    for (i = 0; i < MAX_NAUFRAGOS ; i++ ) {
        if (naufragos[i].livre) continue;
        if (NEAREST(naufragos[i].posx) == posi && NEAREST(naufragos[i].posy) == posj)
            return &(naufragos[i]);
    }
    return NULL;
}

/*seta uma posicao para o naufrago fornecido*/
void setNaufragoPosicao (naufrago *passageiro, float posx, float posy){
    passageiro->posx = posx;
    passageiro->posy = posy;
}

/*seta uma velocidade para o naufrago fornecido*/
void setNaufragoVelocidade (naufrago *passageiro, float vx, float vy) {
    passageiro->vx = vx;
    passageiro->vy = vy;
}

/*obtem a posicao e a velocidade do naufrago fornecido*/
void getNaufragoPosVel (naufrago *passageiro, float *posx, float *posy, float *vx, float *vy) {
    *posx = passageiro->posx;
    *posy = passageiro->posy;
    *vx = passageiro->vx;
    *vy = passageiro->vy;
}

/*seta a posicao para o naufrago fornecido que sera usada na proxima iteracao*/
void setNaufragoNextPosicao (naufrago *passageiro, float nextPosx, float nextPosy) {
    passageiro->nextx = nextPosx;
    passageiro->nexty = nextPosy;
}

/*seta a velocidade para o naufrago fornecido que sera usada na proxima iteracao*/
void setNaufragoNextVelocidade (naufrago *passageiro, float nextVx, float nextVy) {
    passageiro->nextVx = nextVx;
    passageiro->nextVy = nextVy;
}

/*obtem a posicao e a velocidade do naufrago fornecido que sera usado na proxima iteracao*/
void getNaufragoNextPosVel (naufrago *passageiro, float *nextPosx, float *nextPosy, float *nextVx, float *nextVy) {
    *nextPosx = passageiro->nextx;
    *nextPosy = passageiro->nexty;
    *nextVx = passageiro->nextVx;
    *nextVy = passageiro->nextVy;
}

/*a funcao retorna um naufrago do vetor de naufragos, simulando uma lista ligada circular*/
naufrago * nextNaufrago (void) {
    int antigo;
    int controle = 0;
    while (naufragos[proximoNaufrago].livre && controle < MAX_NAUFRAGOS) {
        proximoNaufrago = (proximoNaufrago + 1) % MAX_NAUFRAGOS;
        controle++;
    }
    if (controle == MAX_NAUFRAGOS) {
        printf ("estourou o numero maximo de naufragos!\n");
        return NULL;
    }
    antigo = proximoNaufrago;
    proximoNaufrago = (proximoNaufrago + 1) % MAX_NAUFRAGOS;
    return &(naufragos[antigo]);
}
